Incremental Dynamic Controllability Revisited

Simple Temporal Networks with Uncertainty (STNUs) allow the representation of temporal problems where some durations are determined by nature, as is often the case for actions in planning. As such networks are generated it is essential to verify that they are dynamically controllable – executable regardless of the outcomes of uncontrollable durations – and to convert them to a dispatchable form. The previously published FastIDC algorithm achieves this incrementally and can therefore be used efficiently during plan construction. In this paper we show that FastIDC is not sound when new constraints are added, sometimes labeling networks as dynamically controllable when they are not. We analyze the algorithm, pinpoint the cause, and show how the algorithm can be modified to correctly detect uncontrollable networks. Introduction and Background Time and concurrency are increasingly considered essential in automated planning, with temporal representations varying widely in expressivity. For example, Simple Temporal Problems (STPs, Dechter, Meiri, and Pearl 1991) allow us to efficiently determine whether a set of timepoints (events) can be assigned real-valued times in a way consistent with a set of constraints bounding the temporal distances between timepoints. Clearly the start and end of every action in a plan could be represented as such a timepoint, but we can only represent the possible durations of an action as an STP constraint if the execution mechanism can choose durations arbitrarily within the given bounds. Though this is sometimes true, exact durations are often instead chosen by nature. In STPs with Uncertainty (STPUs, Vidal and Ghallab 1996), a controlled timepoint corresponds to the start of an action while a contingent timepoint corresponds to its end. The distance between a controlled and a contingent timepoint can be limited by a special contingent constraint, representing possible action durations. We then have to find a way to assign times to the controlled timepoints (determine when to start actions) so that for every possible outcome for the contingent constraints (which will be decided by nature during execution), there exists some solution for the ordinary “STP-like” requirement constraints. If an STNU allows controlled timepoints to be scheduled Copyright c © 2013, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. (actions to be started) incrementally given that we immediately receive information when a contingent timepoint occurs (an action ends), it is dynamically controllable (DC) and can be efficiently executed by a dispatcher (Vidal and Fargier 1997). Conversely, ensuring that constraints are satisfied when executing a non-DC plan is impossible: It would require information about future contingent timepoints. If a plan is not dynamically controllable, adding actions cannot restore controllability. Therefore a planner should verify after each action addition whether the plan remains DC, and if not, backtrack. As testing dynamic controllability takes non-trivial time, one can benefit greatly from using an incremental DC verification algorithm rather than redoing the analysis for each new action or constraint. This precludes the use of most known algorithms (Morris, Muscettola, and Vidal 2001; Morris and Muscettola 2005; Morris 2006; Stedl 2004). However, FastIDC does support incremental tightening/addition of constraints, which we need, as well as incremental loosening/removal, which is not strictly required for our purposes assuming chronological backtracking (Stedl and Williams 2005; Shah et al. 2007). In this paper we demonstrate that the tightening/addition algorithm in FastIDC, BackPropagate-Tighten (BPT), cannot always detect plan modifications violating dynamic controllability. We pinpoint and analyze the cause of the problem and show how to solve it, resulting in a sound version of BPT and hence FastIDC.